package com.profgj.profgj.controller;

import com.profgj.profgj.entity.Enterprise;
import com.profgj.profgj.enums.ServerStatus;
import com.profgj.profgj.service.EnterpriseService;
import com.profgj.profgj.utils.EmptyUtils;
import com.profgj.profgj.utils.ReturnOperator;
import com.profgj.profgj.vo.*;
import io.swagger.annotations.*;
import org.apache.commons.io.FileUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.annotation.Secured;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.annotation.Resource;
import javax.annotation.security.RolesAllowed;
import javax.servlet.http.HttpSession;
import javax.servlet.http.Part;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * (企业管理)表控制层
 *
 * @author 杨帅
 * @since 2021-06-22 11:09:35
 */

/**
 * JSON格式返回
 */
@Controller
/**
 * 请求基路径
 */
@RequestMapping("/en")
@Api(tags = {"企业管理"},description = "企业管理")
public class EnterpriseController {

    /**
     * 企业服务对象
     */
    @Resource
    private EnterpriseService enterpriseService;


    /**
     * 临时文件名
     */
    private static String tempfilename;


    /**
     * servlet 默认上传路径作为 临时文件上传路径
     */
    @Value("${spring.servlet.multipart.location}")
    String tempuploadpath = null;

    /**
     * 文件上传的确认路径
     */
    @Value("${system.uploadpath}")
    String uploadpath = null;

    /**
     * 具有序列号的返回空对象 对空new Object() 做了优化
     */
    private EmptyObject emptyObject = new EmptyObject();

    /**
     * 初始化设置校验器
     * @param binder    校验器绑定对象
     */


    /**
     * id查询企业
     * @param id    企业id
     * @param session   Http回话对象内部存储当前登录的用户  user_id / user_name / role_id
     * @return
     */
//    @RolesAllowed(value = {"ROLE_ADMIN"})   // 使用角色方式
//    @PreAuthorize(value="hasAnyRole('ROLE_ADMIN')")     // spring表达式方式
//    @Secured("ROLE_ADMIN")
    @GetMapping("/enterprise/{id}")
    @ApiOperation(value = "id查询企业",consumes = "application/json", produces = "application/json")
    @ApiImplicitParam(name = "id", value = "企业id",required = true, dataType = "Long", paramType = "Long")
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    @ResponseBody
    public ResponseEntity<ResultMsg> enterpriseQueryByIdMethod(@PathVariable("id") Long id, @ApiIgnore HttpSession session) {

        // 参数校验
        if(!EmptyUtils.isLongEmpty(id)){
            return ReturnOperator.createResultMsg("",ServerStatus.ID_NOT_NULL, ServerStatus.ERROR,
                    new ArrayList<>(), emptyObject, HttpStatus.OK);
        }

        // 取得当前登录的用户角色id
        Integer role_id = Integer.valueOf(String.valueOf(session.getAttribute("role_id")));
        // 取得当前登录的用户id
        Integer user_id = Integer.valueOf(String.valueOf(session.getAttribute("user_id")));
        Enterprise enterprise = null;
        if (role_id != 1) {
            //不是管理员情况下
            // id查询企业数据库
            enterprise = enterpriseService.queryByIdAndUserId(id,user_id);
        } else {
            //是管理员情况下
            // id查询企业数据库
            enterprise = enterpriseService.queryById(id);
        }

        // 判断查询结果是否为空
        if(!EmptyUtils.isEnterpriseEmpty(enterprise)) {
            // 企业对象为空
            return ReturnOperator.createResultMsg("",ServerStatus.EN_NOT_EXISTS, ServerStatus.ERROR,
                    new ArrayList<>(), emptyObject, HttpStatus.OK);
        }

        // 数据请求成功返回
        return ReturnOperator.createResultMsg(ServerStatus.QUERY_MESSAGE_SUCCESS,"", ServerStatus.OK,
                new ArrayList<>(), enterprise, HttpStatus.OK);
    }


    /**
     * 查询企业列表
     * @param draw     绘制次数
     * @param start     查询起始位置
     * @param length    查询条数
     * @param session   Http回话对象内部存储当前登录的用户id  user_id / user_name / role_id
     * @return
     */
    @GetMapping("/enterprise/list/nokeyword")
    @ApiOperation(value = "分页查询企业",consumes = "application/json", produces = "application/json")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "draw", value = "绘制次数",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "start", value = "查询起始位置",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "length", value = "查询条数",required = true, dataType = "Integer", paramType = "Integer")
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseQueryListMethod(Integer draw,
                                                                Integer start,
                                                                Integer length,
                                                                @ApiIgnore HttpSession session){

        // 分页参数校验
        if(!EmptyUtils.isIntegerEmpty(start) && !EmptyUtils.isIntegerEmpty(length)){
            return ReturnOperator.createResultMsg("",ServerStatus.LIMIT_PARAM_NOT_NULL, ServerStatus.ERROR,
                    new ArrayList<>(), emptyObject, HttpStatus.OK);
        }

        // 取得当前登录的用户角色id
        Integer role_id = Integer.valueOf(String.valueOf(session.getAttribute("role_id")));
        // 取得当前登录的用户id
        Integer user_id = Integer.valueOf(String.valueOf(session.getAttribute("user_id")));
        List<Enterprise> enterpriseList = null;
        List<EnterpriseVo> enterpriseVoList = new ArrayList<>();
        if (role_id != 1) {
            //不是管理员情况下
            // 用户id分页查询企业 列表
            enterpriseList = enterpriseService.queryAllByUserIdLimit(start, length, user_id);
        } else {
            //是管理员情况下
            // 分页询企业 返回列表
            enterpriseList = enterpriseService.queryAllByLimit(start, length);
        }

        // 对查询结果进行校验
        if(!EmptyUtils.isEnterpriseListEmpty(enterpriseList)) {
            return ReturnOperator.createResultMsg("",ServerStatus.EN_NOT_EXISTS, ServerStatus.ERROR,
                    new ArrayList<>(), emptyObject, HttpStatus.OK);
        }

        // 对子公司进行添加处理
        for (Enterprise enterprise : enterpriseList) {
            // 创建附加信息的企业对象
            EnterpriseVo enterpriseVo = new EnterpriseVo();
            List<String> enNameList = new ArrayList<>();
            // 将原生的企业信息拷贝到附加企业对象中
            BeanUtils.copyProperties(enterprise,enterpriseVo);
            // 判断查询出来的企业是否有子企业
            if (enterprise.getsId() == null || enterprise.getsId().isEmpty()) {


            }else {
                // 子企业有可能多个 字符串分割
                String[] sid_arr = enterprise.getsId().split(",");
                // 循环遍历
                for(String sid: sid_arr){
                    // 查询出子企业信息
                    Enterprise enterprise_sub = enterpriseService.queryById(Long.valueOf(sid));
                    if (enterprise_sub != null) {
                        // 将子企业名称添加到容器中
                        enNameList.add(enterprise_sub.getEnName());
                    }
                }
                // 将包含子企业名称容器添加到当前企业信息中
                enterpriseVo.setSub_en_name(enNameList);
            }
            enterpriseVoList.add(enterpriseVo);
        }

        // 返回字段结构
        // draw     绘制次数
        // recordsTotal     总记录数
        // recordsFiltered  总过滤记录数
        // data             数据list
        Map<String,Object> data = new HashMap<>();
        data.put("draw",1);
        data.put("recordsTotal",enterpriseVoList.size());
        data.put("recordsFiltered",enterpriseVoList.size());
        data.put("data",enterpriseVoList);

        // 数据请求成功返回
        return ReturnOperator.createResultMsg(ServerStatus.QUERY_MESSAGE_SUCCESS,"", ServerStatus.OK,
                enterpriseVoList, data, HttpStatus.OK);
    }


    /**
     * 分页查询关键字企业
     * @param draw  绘制的次数
     * @param start  查询起始位置
     * @param length    查询条数
     * @param search     查询的关键字
     * @param session   Http回话对象内部存储当前登录的用户id  user_id / user_name / role_id
     * @return
     */
    @GetMapping("/enterprise/list")
    @ApiOperation(value = "分页查询关键字企业",consumes = "application/json", produces = "application/json")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "draw", value = "绘制次数",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "start", value = "查询起始位置",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "length", value = "查询条数",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "search", value = "关键字",required = true, dataType = "String", paramType = "String")
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ReturnResult> enterpriseQueryWordMethod(Integer draw,
                                                                   Integer start,
                                                                   Integer length,
                                                                   String search,
                                                                   @ApiIgnore HttpSession session){

        // 分页参数校验
        if(!EmptyUtils.isIntegerEmpty(start) && !EmptyUtils.isIntegerEmpty(length)){
            return ReturnOperator.createResultMsg(draw,0, 0,
                    new ArrayList<>(), HttpStatus.OK);
        }

        // 取得当前登录的用户角色id
        Integer role_id = Integer.valueOf(String.valueOf(session.getAttribute("role_id")));
        // 取得当前登录的用户id
        Integer user_id = Integer.valueOf(String.valueOf(session.getAttribute("user_id")));
        List<Enterprise> enterpriseList = null;
        List<EnterpriseVo> enterpriseVoList = new ArrayList<>();
        Integer totalCount = 0;

        if (role_id != 1) {
            //不是管理员情况下

            // 判断查询关键字是否为空
            if(EmptyUtils.isStringEmpty(search)){
                // 使用关键字和用户id查询计算总记录数
                totalCount = enterpriseService.queryAllByKeyWordAndUserId(search,user_id).size();
                // 用户id分页查询企业 列表
                enterpriseList = enterpriseService.queryByWordAndUserIdLimit(search, start, length, user_id);

            } else {

                // 使用用户id查询计算总记录数
                totalCount = enterpriseService.queryAllByUserId(user_id).size();
                // 关键字为空则查询无关键字的
                enterpriseList = enterpriseService.queryAllByUserIdLimit(start, length, user_id);
            }

        } else {
            //是管理员情况下

            // 判断查询关键字是否为空
            if(EmptyUtils.isStringEmpty(search)){

                // 关键字查询统计出总 记录数
                totalCount = enterpriseService.queryAllByKeyWord(search).size();
                // 关键字查询企业 返回列表
                enterpriseList = enterpriseService.queryByWordLimit(search, start, length);

            } else {

                // 无关键字查询统计出总 记录数
                totalCount = enterpriseService.queryAll().size();
                // 不使用关键字查询
                enterpriseList = enterpriseService.queryAllByLimit(start, length);
            }

        }

        // 判断list是否为空
        if(!EmptyUtils.isEnterpriseListEmpty(enterpriseList)) {
            return ReturnOperator.createResultMsg(draw,0, 0,
                    new ArrayList<>(),  HttpStatus.OK);
        }

        // 对子企业进行添加处理
        for (Enterprise enterprise : enterpriseList) {
            // 创建附加信息的企业对象
            EnterpriseVo enterpriseVo = new EnterpriseVo();
            List<String> enNameList = new ArrayList<>();
            // 将原生的企业信息拷贝到附加企业对象中
            BeanUtils.copyProperties(enterprise,enterpriseVo);
            // 判断查询出来的企业是否有子企业
            if (enterprise.getsId() == null || enterprise.getsId().isEmpty()) {

            }else {
                // 子企业有可能多个 字符串分割
                String[] sid_arr = enterprise.getsId().split(",");
                // 循环遍历
                for(String sid: sid_arr){
                    // 查询出子企业信息
                    Enterprise enterprise_sub = enterpriseService.queryById(Long.valueOf(sid));
                    if (enterprise_sub != null) {
                        // 将子企业名称添加到list容器中
                        enNameList.add(enterprise_sub.getEnName());

                    }
                }
                // 将包含子企业的容器添加到当前企业信息中
                enterpriseVo.setSub_en_name(enNameList);
            }
            enterpriseVoList.add(enterpriseVo);
        }

        // 返回字段结构
        // draw             绘制次数
        // recordsTotal     总记录数
        // recordsFiltered  总过滤记录数
        // data             数据list

        // 数据请求成功返回
        return ReturnOperator.createResultMsg(draw, totalCount,
                totalCount, enterpriseVoList, HttpStatus.OK);

    }

    /**
     * 用户id查询该用户关联下的所有企业
     * @param userId    用户id
     * @return
     */
    @GetMapping("/enterprise/userid/{userId}")
    @ApiOperation(value = "用户id查询该用户关联下的所有企业",consumes = "application/json", produces = "application/json")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userId", value = "用户id",required = true, dataType = "Integer", paramType = "Integer"),
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseQueryAllByUserIdMethod(@PathVariable("userId")Integer userId){

        // 参数校验
        if (!EmptyUtils.isIntegerEmpty(userId)) {
            return ReturnOperator.createResultMsg("", ServerStatus.ID_NOT_NULL, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }
        // 用户id查询该用户关联下的所有企业
        List<Enterprise> enterprises = enterpriseService.queryAllByUserId(userId);

        // 查询结果校验
        if (!EmptyUtils.isEnterpriseListEmpty(enterprises)) {
            return ReturnOperator.createResultMsg("", ServerStatus.QUERY_MESSAGE_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 返回数据
        return ReturnOperator.createResultMsg(ServerStatus.QUERY_MESSAGE_SUCCESS, "", ServerStatus.OK,
                enterprises, emptyObject, HttpStatus.OK);
    }

    @GetMapping("/enterprise/all")
    @ApiOperation(value = "查询所有企业",consumes = "application/json", produces = "application/json")
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseQueryAllMethod(){

        // 用户id查询该用户关联下的所有企业
        List<Enterprise> enterprises = enterpriseService.queryAll();

        // 查询结果校验
        if (!EmptyUtils.isEnterpriseListEmpty(enterprises)) {
            return ReturnOperator.createResultMsg("", ServerStatus.QUERY_MESSAGE_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 返回数据
        return ReturnOperator.createResultMsg(ServerStatus.QUERY_MESSAGE_SUCCESS, "", ServerStatus.OK,
                enterprises, emptyObject, HttpStatus.OK);
    }

    /**
     *  添加企业
     * @param rId           父企业id
     * @param enName        企业名称
     * @param enPersionName             企业负责人
     * @param enTel                     企业联系电话
     * @param projectReportPerson       上报人
     * @param projectReportPersonPost   上报人的职务
     * @param projectReportPersonTel    上报人的联系电弧
     * @param enable       企业是否运营中
     * @param userId     关联的用户id
     * @param file      上传的企业营业执照
     * @param session   会话session
     * @return
     */
    @PostMapping("/enterprise")
    @ApiOperation(value = "添加企业",consumes = "application/x-www-form-urlencoded", produces = "application/json")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "rId", value = "父企业id",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enName", value = "企业名称",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enPersionName", value = "企业负责人",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enTel", value = "企业联系电话",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "projectReportPerson", value = "上报人",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "projectReportPersonPost", value = "上报人的职务",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "projectReportPersonTel", value = "上报人的联系电话",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enable", value = "是否运营",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "userId", value = "用户id",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "file", value = "上传的文件",required = true, dataType = "File", paramType = "File"),
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseAddMethod(Long rId,
                                                         String enName,
                                                         String enPersionName,
                                                         String enTel,
                                                         String projectReportPerson,
                                                         String projectReportPersonPost,
                                                         String projectReportPersonTel,
                                                         String enable,
                                                         Integer userId,
                                                         Part file,
                                                         @ApiIgnore HttpSession session)  {

        // 对象参数校验
        if (!EmptyUtils.isLongEmpty(rId) && !EmptyUtils.isStringEmpty(enName)
            && enable != null){
            return ReturnOperator.createResultMsg("", ServerStatus.DATA_INSERT_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 上传文件校验
        if(!EmptyUtils.isNotFile(file)) {
            return ReturnOperator.createResultMsg("", ServerStatus.FILE_UPLOAD_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 构建企业对象
        Enterprise enterprise = new Enterprise();
        enterprise.setrId(rId);
        enterprise.setEnName(enName);
        enterprise.setEnPersionName(enPersionName);
        enterprise.setEnTel(enTel);
        enterprise.setProjectReportPerson(projectReportPerson);
        enterprise.setProjectReportPersonPost(projectReportPersonPost);
        enterprise.setProjectReportPersonTel(projectReportPersonTel);
        enterprise.setEnable(enable == null ? 0 : "on".equalsIgnoreCase(enable)?1:0);
        enterprise.setDeleted(0);

        // 先查询是否有该公司同名称
        Enterprise enterprise_tmp = enterpriseService.queryByWord(enterprise.getEnName());
        if(EmptyUtils.isEnterpriseEmpty(enterprise_tmp)) {
            return ReturnOperator.createResultMsg("", ServerStatus.EN_EXISTS, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        try{
            // 写入文件 实际写入到application.yml中配置的 classpath下的tempupload下
            // 也就是main目录下的resources下的static/tempload 存放临时位置
            tempfilename = file.getSubmittedFileName();
            file.write(tempfilename);
        }catch (Exception e) {
            e.printStackTrace();
        }

        // 取得当前登录的用户角色id
        Integer role_id = Integer.valueOf(String.valueOf(session.getAttribute("role_id")));
        Integer user_id = Integer.valueOf(String.valueOf(session.getAttribute("user_id")));
        // 如果当前登录的不是管理员用户(企业用户)
        if (role_id != 1) {
            // 获取当前登录的企业用户id 关联到企业 本关联只用来限制企业用户只查看自己
            enterprise.setEnUserId(user_id);
        }else {
            // 是管理员的情况下下设置表单选中的用户id
            enterprise.setEnUserId(userId);
        }

        // 添加企业到数据库
        Enterprise enterprise_new = enterpriseService.insert(enterprise);

        if(enterprise_new.getrId() != null){
            // 查询父企业
            Enterprise enterprise_parnent = enterpriseService.queryById(enterprise_new.getrId());
            StringBuilder strB = new StringBuilder();
            // 判断下父企业是否已经存在子企业id字符串
            if (enterprise_parnent.getsId() == null || enterprise_parnent.getsId().isEmpty()){
                // 不存在直接添加
                strB.append(enterprise_new.getId() + ",");
            }else {
                // 存在拼接之前的
                strB.append(enterprise_parnent.getsId() +  enterprise_new.getId() + ",");
            }

            // 将父企业中的子企业id赋值
            enterprise_parnent.setsId(strB.toString());
            // 更新父企业
            enterpriseService.update(enterprise_parnent);
        }

        /**
         * 临时文件操作
         */

        // 构建临时文件对象
        File file_temp = new File(tempuploadpath + tempfilename);

        // 判断临时上传的文件不存在情况下
        if (!file_temp.exists()) {
            return ReturnOperator.createResultMsg("", "文件临时上传已过期,请在1分钟之内处理", ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        /**
         * 将临时文件移动到目标位置
         */
        // 设置日期时间格式
        SimpleDateFormat datef = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat timef = new SimpleDateFormat("HH-mm");
        // 获取当前系统时间对象
        Date date = new Date();
        // 拼接 文件夹日期时间名称  例如:2021-6-25-15-55
        String new_path = "/" + datef.format(date) + "/" + timef.format(date) + "/";
        // 构建文件夹对象
        File upload_folder = new File(uploadpath  + enterprise_new.getId() + new_path);
        // 判断文件夹是否存在
        if (!upload_folder.exists()) {
            // 不存在则创建文件夹
            upload_folder.mkdirs();
        }
        // 构造目标存在文件对象   resources目录+企业id+当前系统日期时间+目标文件名
        File upload_file = new File(uploadpath + enterprise_new.getId() + new_path + tempfilename);
        try{
            // 将临时文件移动到目标存放位置
            FileUtils.moveFile(file_temp, upload_file);
        }catch (IOException e) {
            e.printStackTrace();
        }
        // 保存文件相对路径位置到对象中
        enterprise_new.setLicenseImg(uploadpath  + enterprise_new.getId() + new_path + tempfilename);


        // 将营业执照更新到数据库
        Enterprise enterprise_update = enterpriseService.update(enterprise_new);

        // 判断数据插入是否成功
        if(!EmptyUtils.isEnterpriseEmpty(enterprise_update)) {
            return ReturnOperator.createResultMsg("", ServerStatus.DATA_UPDATE_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 返回数据
        return ReturnOperator.createResultMsg(ServerStatus.DATA_INSERT_SUCCESS, "", ServerStatus.OK,
                new ArrayList(), enterprise_update, HttpStatus.OK);
    }

    /**
     *   修改企业
     * @param id            企业id
     * @param rId           父企业id
     * @param enName        企业名称
     * @param enPersionName 企业负责人
     * @param enTel         企业联系电话
     * @param projectReportPerson   上报人
     * @param projectReportPersonPost   上报人职务
     * @param projectReportPersonTel    上报人联系电话
     * @param enable       企业是否运营中
     * @param userId     关联的用户id
     * @param file      上传的企业营业执照
     * @param session   Http回话对象内部存储当前登录的用户id  user_id / user_name
     * @return
     */
    @PostMapping("/enterprise/change")
    @ApiOperation(value = "修改企业",consumes = "application/json", produces = "application/json")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "企业id",required = true, dataType = "Long", paramType = "Long"),
            @ApiImplicitParam(name = "rId", value = "父企业id",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enName", value = "企业名称",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enPersionName", value = "企业负责人",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enTel", value = "企业联系电话",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "projectReportPerson", value = "上报人",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "projectReportPersonPost", value = "上报人的职务",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "projectReportPersonTel", value = "上报人的联系电话",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "enable", value = "是否运营",required = true, dataType = "String", paramType = "String"),
            @ApiImplicitParam(name = "userId", value = "用户id",required = true, dataType = "Integer", paramType = "Integer"),
            @ApiImplicitParam(name = "file", value = "上传的文件",required = true, dataType = "File", paramType = "File"),
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseChangeByIdMethod(Long id,
                                                                Long rId,
                                                                String enName,
                                                                String enPersionName,
                                                                String enTel,
                                                                String projectReportPerson,
                                                                String projectReportPersonPost,
                                                                String projectReportPersonTel,
                                                                String enable,
                                                                Integer userId,
                                                                Part file,
                                                                @ApiIgnore HttpSession session){

        // 对象参数校验
        if (!EmptyUtils.isLongEmpty(id) &&
                !EmptyUtils.isLongEmpty(rId) && !EmptyUtils.isStringEmpty(enName)
                && enable != null){
            return ReturnOperator.createResultMsg("", ServerStatus.DATA_UPDATE_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 先查询是否有该公司同名称
        Enterprise enterprise = enterpriseService.queryById(id);
        if(!EmptyUtils.isEnterpriseEmpty(enterprise)) {
            return ReturnOperator.createResultMsg("", ServerStatus.EN_NOT_EXISTS, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 构建企业对象
        enterprise.setrId(rId);
        enterprise.setEnName(enName);
        enterprise.setEnPersionName(enPersionName);
        enterprise.setEnTel(enTel);
        enterprise.setProjectReportPerson(projectReportPerson);
        enterprise.setProjectReportPersonPost(projectReportPersonPost);
        enterprise.setProjectReportPersonTel(projectReportPersonTel);
        enterprise.setEnable(enable == null ? 0 : "on".equalsIgnoreCase(enable)?1:0);
        enterprise.setDeleted(0);

        // 上传文件校验
        if(!file.getSubmittedFileName().isEmpty()) {

            try{
                // 写入文件 实际写入到application.yml中配置的 classpath下的tempupload下
                // 也就是main目录下的resources下的static/tempload 存放临时位置
                tempfilename = file.getSubmittedFileName();
                file.write(tempfilename);
            }catch (Exception e) {
                e.printStackTrace();
            }

            // 取得当前登录的用户角色id
            Integer role_id = Integer.valueOf(String.valueOf(session.getAttribute("role_id")));
            // 如果当前登录的不是管理员用户(企业用户)
            if (role_id != 1) {
                // 获取当前登录的企业用户id 关联到企业 本关联只用来限制企业用户只查看自己
                Integer user_id = Integer.valueOf(String.valueOf(session.getAttribute("user_id")));
                enterprise.setEnUserId(user_id);
            }else {
                // 是管理员的情况下下设置表单选中的用户id
                enterprise.setEnUserId(userId);
            }

            /**
             * 临时文件操作
             */

            // 构建临时文件对象
            File file_temp = new File(tempuploadpath + tempfilename);

            // 判断临时上传的文件不存在情况下
            if (!file_temp.exists()) {
                return ReturnOperator.createResultMsg("", "文件临时上传已过期,请在1分钟之内处理", ServerStatus.ERROR,
                        new ArrayList(), emptyObject, HttpStatus.OK);
            }

            // 删除以前的文件
            File oldFile = new File(enterprise.getLicenseImg());
            // 判断以前文件是否存在
            if (oldFile.exists()){
                // 存在则删除
                oldFile.delete();
            }


            /**
             * 将临时文件移动到目标位置
             */
            // 设置日期时间格式
            SimpleDateFormat datef = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat timef = new SimpleDateFormat("HH-mm");
            // 获取当前系统时间对象
            Date date = new Date();
            // 拼接 文件夹日期时间名称  例如:2021-6-25-15-55
            String new_path = "/" + datef.format(date) + "/" + timef.format(date) + "/";
            // 构建文件夹对象
            File upload_folder = new File(uploadpath  + enterprise.getId() + new_path);
            // 判断文件夹是否存在
            if (!upload_folder.exists()) {
                // 不存在则创建文件夹
                upload_folder.mkdirs();
            }
            // 构造目标存在文件对象   resources目录+企业id+当前系统日期时间+目标文件名
            File upload_file = new File(uploadpath + enterprise.getId() + new_path + tempfilename);
            try{
                // 将临时文件移动到目标存放位置
                FileUtils.moveFile(file_temp, upload_file);
            }catch (IOException e) {
                e.printStackTrace();
            }
            // 保存文件相对路径位置到对象中
            enterprise.setLicenseImg(uploadpath  + enterprise.getId() + new_path + tempfilename);
        }



        // 字符缓冲区
        StringBuilder strB = new StringBuilder();
        // 如果有父企业
        if(enterprise.getrId() != null) {
            // 查询之前的父企业
            Enterprise enterprise_old = enterpriseService.queryById(id);
            if (enterprise_old.getrId() != null){
                // 判断之前的父企业id 是否等于新父企业的id
                if (!enterprise_old.getrId().equals(rId)) {
                    //不等于的情况下
                    // 从之前的父企业中将当前的子企业id移除
                    Enterprise enterprise_parent = enterpriseService.queryById(enterprise_old.getrId());
                    // 字符串替换掉
                    String replace = enterprise_parent.getsId().replace(String.valueOf(enterprise_old.getId() + ","), "");

                    enterprise_parent.setsId(replace);

                    // 更新之前的父企业
                    enterpriseService.update(enterprise_parent);

                    // 新
                    // 查询出新的父企业
                    Enterprise enterprise_parent_new = enterpriseService.queryById(rId);
                    // 新父企业的子企业字符串不为空
                    if (enterprise_parent_new.getsId() == null || enterprise_parent_new.getsId().isEmpty()) {
                        // 为空直接拼接
                        strB.append(enterprise.getId() + ",");
                    } else {
                        // 不为空 则 原来+ 子企业id
                        strB.append(enterprise_parent_new.getsId() + enterprise.getId() + ",");
                    }
                    // 将拼接好的子企业字符串 设置到新父企业信息中
                    enterprise_parent_new.setsId(strB.toString());
                    // 更新新的父企业
                    enterpriseService.update(enterprise_parent_new);
                }
            }

        }
        // 将当前企业更新
        Enterprise enterprise_update = enterpriseService.update(enterprise);

        // 判断数据插入是否成功
        if(!EmptyUtils.isEnterpriseEmpty(enterprise_update)) {
            return ReturnOperator.createResultMsg("", ServerStatus.DATA_UPDATE_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 返回数据
        return ReturnOperator.createResultMsg(ServerStatus.DATA_UPDATE_SUCCESS, "", ServerStatus.OK,
                new ArrayList(), emptyObject, HttpStatus.OK);
    }


    /**
     * 根据ID删除企业
     * @param id    企业id
     * @return
     */
    @DeleteMapping("/enterprise/{id}")
    @ApiOperation(value = "根据ID删除企业",consumes = "application/json", produces = "application/json")
    @ApiImplicitParam(name = "id",value = "企业id",required = true, dataType = "Long", paramType = "Long", dataTypeClass = Long.class)
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseDeleteByIdMethod(@PathVariable("id")Long id,@ApiIgnore HttpSession session){

        if(!EmptyUtils.isLongEmpty(id)) {
            // 返回数据
            return ReturnOperator.createResultMsg("", ServerStatus.ID_NOT_NULL, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 根据id删除企业数据库
        if(!enterpriseService.deleteById(id)) {
            return ReturnOperator.createResultMsg("", ServerStatus.DATA_DELETE_ERR, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        return ReturnOperator.createResultMsg(ServerStatus.DATA_DELETE_SUCCESS, "", ServerStatus.OK,
                new ArrayList(), new Boolean(true), HttpStatus.OK);
    }

    /**
     * 通过id数组批量删除
     * @param ids   批量id数组
     * @return
     */
    @DeleteMapping("/enterprise")
    @ApiOperation(value = "通过id数组批量删除",consumes = "application/json", produces = "application/json")
    @ApiImplicitParam(name = "ids",value = "企业id数组",required = true, dataType = "Long", paramType = "Long[]", dataTypeClass = Long.class)
    @ApiResponses({
            @ApiResponse(code = 200, message = "表明该请求被成功地完成,所请求的资源发送到客户端"),
            @ApiResponse(code = 401, message = "请求要求身份验证,常见于需要登录而用户未登录的情况"),
            @ApiResponse(code = 403, message = "服务器拒绝请求,常见于机密信息或复制其它登录而用户未登录的情况"),
            @ApiResponse(code = 404, message = "服务器无法取得所请求的网页,请求资源不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseEntity<ResultMsg> enterpriseDeleteListByIDMethod(Long[] ids,@ApiIgnore HttpSession session){

        // 判断数组是否为空
        if(EmptyUtils.isIdsEmpty(ids)) {
            return ReturnOperator.createResultMsg("", ServerStatus.ID_NOT_NULL, ServerStatus.ERROR,
                    new ArrayList(), emptyObject, HttpStatus.OK);
        }

        // 循环id删除
        for(Long id : ids) {
            enterpriseService.deleteById(id);
        }

        // 返回数据
        return ReturnOperator.createResultMsg(ServerStatus.DATA_DELETE_SUCCESS, "", ServerStatus.OK,
                new ArrayList(), new Boolean(true), HttpStatus.OK);
    }


}
